home *** CD-ROM | disk | FTP | other *** search
/ Scene Storm / Scene Storm - Volume 1.iso / coding / tools / gcc / gcc270_src.lha / gcc-2.7.0-amiga / config / 1750a / 1750a.md < prev    next >
Encoding:
Text File  |  1995-06-15  |  33.8 KB  |  1,261 lines
  1. ;;- Machine description for GNU compiler
  2. ;;- MIL-STD-1750A version.
  3. ;; Copyright (C) 1994 Free Software Foundation, Inc.
  4. ;; Contributed by O.M.Kellogg, DASA (okellogg@salyko.cube.net).
  5.  
  6. ;; This file is part of GNU CC.
  7.  
  8. ;; GNU CC is free software; you can redistribute it and/or modify
  9. ;; it under the terms of the GNU General Public License as published by
  10. ;; the Free Software Foundation; either version 1, or (at your option)
  11. ;; any later version.
  12.  
  13. ;; GNU CC is distributed in the hope that it will be useful,
  14. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. ;; GNU General Public License for more details.
  17.  
  18. ;; You should have received a copy of the GNU General Public License
  19. ;; along with GNU CC; see the file COPYING.  If not, write to
  20. ;; the Free Software Foundation, 59 Temple Place - Suite 330,
  21. ;; Boston, MA 02111-1307, USA.
  22.  
  23.  
  24. ;;- instruction definitions
  25.  
  26. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  27.  
  28. ;;- When naming insn's (operand 0 of define_insn) be careful about using
  29. ;;- names from other targets machine descriptions.
  30.  
  31. ;; MIL-STD-1750 specific remarks:
  32. ;;
  33. ;; 1) BITS_PER_UNIT = 16
  34. ;;
  35. ;; 2) GCC   to    MIL-STD-1750       data type mappings:
  36. ;;    QImode => single integer (16 bits or 1 reg).
  37. ;;    HImode => double integer (32 bits or 2 regs).
  38. ;;    HFmode => single precision float (32 bits or 2 regs).
  39. ;;    TQFmode => extended precision float (48 bits or 3 regs).
  40. ;; 
  41. ;; 3) Immediate integer operands Constraints:
  42. ;;    'I'  1 .. 16
  43. ;;    'J' -1 ..-16
  44. ;;    'K'  0 .. 15
  45. ;;    'L'  0 .. 255
  46. ;;    'M' -32768 .. 32767
  47. ;;    'O' => 0  (for optimizations and GCC quirks)
  48. ;;
  49. ;; Further notes:
  50. ;;-  Assembly output ending in ".M" are macros in file M1750.INC
  51.  
  52.  
  53. ;; stackpush
  54. (define_insn ""
  55.   [(set (match_operand:QI 0 "push_operand" "=<")
  56.         (match_operand:QI 1 "general_operand" "r"))]
  57.   ""
  58.   "pshm r%1,r%1")
  59.  
  60. (define_insn ""
  61.   [(set (match_operand:HI 0 "push_operand" "=<")
  62.         (match_operand:HI 1 "general_operand" "r"))]
  63.   ""
  64.   "*
  65.    { 
  66.         rtx new_operands[2];
  67.         new_operands[0] = operands[1];
  68.         new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[1])+1);
  69.    } ")
  70.  
  71. (define_insn ""
  72.   [(set (match_operand:HF 0 "push_operand" "=<")
  73.         (match_operand:HF 1 "general_operand" "r"))]
  74.   ""
  75.   "*
  76.   { 
  77.         rtx new_operands[2];
  78.         new_operands[0] = operands[1];
  79.         new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[1])+1);
  80.         output_asm_insn(\"pshm r%0,r%1\",new_operands);
  81.         return \"\;\";
  82.    } ")
  83.  
  84. (define_insn ""
  85.   [(set (match_operand:TQF 0 "push_operand" "=<")
  86.         (match_operand:TQF 1 "general_operand" "r"))]
  87.   ""
  88.   "*
  89.    { 
  90.         rtx new_operands[2];
  91.         new_operands[0] = operands[1];
  92.         new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[1])+2);
  93.         output_asm_insn(\"pshm r%0,r%1\",new_operands);
  94.         return \"\;\";
  95.    } ")
  96.  
  97. ;; stackpop
  98. (define_insn ""
  99.   [(set (match_operand:QI 0 "general_operand" "=r")
  100.         (match_operand:QI 1 "push_operand" ">"))]
  101.   ""
  102.   "popm r%1,r%1")
  103.  
  104. (define_insn ""
  105.   [(set (match_operand:HI 0 "general_operand" "=r")
  106.         (match_operand:HI 1 "push_operand" ">"))]
  107.   ""
  108.   "*
  109.    { 
  110.         rtx new_operands[2];
  111.         new_operands[0] = operands[0];
  112.         new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+1);
  113.         output_asm_insn(\"popm r%0,r%1\",new_operands);
  114.         return \"\;\";
  115.    } ")
  116.  
  117. (define_insn ""
  118.   [(set (match_operand:HF 0 "general_operand" "=r")
  119.         (match_operand:HF 1 "push_operand" ">"))]
  120.   ""
  121.   "*
  122.    { 
  123.         rtx new_operands[2];
  124.         new_operands[0] = operands[0];
  125.         new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+1);
  126.         output_asm_insn(\"popm r%0,r%1\",new_operands);
  127.         return \"\;\";
  128.    } ")
  129.  
  130. (define_insn ""
  131.   [(set (match_operand:TQF 0 "general_operand" "=r")
  132.         (match_operand:TQF 1 "push_operand" ">"))]
  133.   ""
  134.   "*
  135.    { 
  136.         rtx new_operands[2];
  137.         new_operands[0] = operands[0];
  138.         new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+2);
  139.         output_asm_insn(\"popm r%0,r%1\",new_operands);
  140.         return \"\;\";
  141.    } ")
  142.  
  143. ;; Test operations. These shouldn't really occur for 1750:
  144. ;; all important instructions set the cc's (see NOTICE_UPDATE_CC)
  145.  
  146. (define_insn "tstqi"
  147.   [(set (cc0)
  148.         (match_operand:QI 0 "register_operand" "r"))]
  149.   ""
  150.   "lr r%0,r%0   ; from tstqi")
  151.  
  152. (define_insn "tsthi"
  153.   [(set (cc0)
  154.         (match_operand:HI 0 "register_operand" "r"))]
  155.   ""
  156.   "dlr r%0,r%0   ; from tsthi")
  157.  
  158. (define_insn "tsthf"
  159.   [(set (cc0)
  160.         (match_operand:HF 0 "register_operand" "r"))]
  161.   ""
  162.   "dlr r%0,r%0   ; from tsthf")
  163.  
  164. ;; This one is happy with "roughly zero" :-)  (should be improved)
  165. (define_insn "tsttqf"
  166.   [(set (cc0)
  167.         (match_operand:TQF 0 "register_operand" "r"))]
  168.   ""
  169.   "dlr r%0,r%0   ; from tsttqf")
  170.  
  171.  
  172. ;; block move.
  173.  
  174. ; there is a problem with this insn in gcc-2.2.3
  175. ; (clobber (match_dup 2)) does not prevent use of this operand later
  176. ;
  177. (define_insn "movstrqi"
  178.   [(set (mem:BLK (match_operand:QI 0 "register_operand" "r"))
  179.     (mem:BLK (match_operand:QI 1 "register_operand" "r")))
  180.    (use (match_operand:QI 2 "register_operand" "r"))
  181.    (use (match_operand:QI 3 "immediate_operand" ""))
  182.    (clobber (match_dup 0))
  183.    (clobber (match_dup 1))
  184.    (clobber (match_dup 2))]
  185.   ""
  186.   "* return (char *)movcnt_regno_adjust(operands); ")
  187.  
  188.  
  189. ;; compare instructions.
  190.  
  191. (define_insn "cmpqi"
  192.   [(set (cc0)
  193.         (compare (match_operand:QI 0 "register_operand" "r,r,r,r,r")
  194.                  (match_operand:QI 1 "general_operand"  "I,J,i,r,m")))]
  195.   ""
  196.   "@
  197.      cisp r%0,%1
  198.      cisn r%0,%J1
  199.      cim  r%0,%1
  200.      cr   r%0,r%1
  201.      c    r%0,%1 ")
  202.  
  203. (define_insn "cmphi"
  204.   [(set (cc0)
  205.         (compare (match_operand:HI 0 "general_operand" "r,r")
  206.                  (match_operand:HI 1 "general_operand" "r,m")))]
  207.   ""
  208.   "@
  209.     dcr r%0,r%1
  210.     dc  r%0,%1 ")
  211.  
  212. (define_insn "cmphf"
  213.  [(set (cc0)
  214.        (compare (match_operand:HF 0 "general_operand" "r,r")
  215.                 (match_operand:HF 1 "general_operand" "r,m")))]
  216.  ""
  217.  "@
  218.    fcr r%0,r%1
  219.    fc  r%0,%1 ")
  220.  
  221. (define_insn "cmptqf"
  222.   [(set (cc0)
  223.         (compare (match_operand:TQF 0 "general_operand" "r,r")
  224.                  (match_operand:TQF 1 "general_operand" "r,m")))]
  225.   ""
  226.   "@
  227.     efcr r%0,r%1
  228.     efc  r%0,%1 ")
  229.  
  230.  
  231. ;; truncation instructions
  232. ;;- 1750: any needed?
  233.  
  234. (define_insn "trunchiqi2"
  235.   [(set (match_operand:QI 0 "register_operand" "=r")
  236.         (truncate:QI
  237.          (match_operand:HI 1 "register_operand" "r")))]
  238.   ""
  239.   "*
  240.      {
  241.         REGNO(operands[1]) += 1;
  242.         return \"lr r%0,r%1  ;trunchiqi2\";
  243.      } ")
  244.  
  245. ;; zero extension instructions
  246.  
  247. (define_insn "zero_extendqihi2"
  248.   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
  249.         (zero_extend:HI (match_operand:QI 1 "general_operand" "r,m,i")))]
  250.   ""
  251.   "*
  252.       {
  253.         output_asm_insn(\"xorr r%0,r%0   ;zero_extendqihi2\",operands);
  254.         REGNO(operands[0]) += 1;
  255.         switch (which_alternative)
  256.           {
  257.             case 0:
  258.               return \"lr  r%0,r%1\";
  259.             case 1:
  260.               return \"l   r%0,%1\";
  261.             case 2:
  262.               return \"lim r%0,%1\";
  263.           }
  264.       } ")
  265.  
  266. ;; sign extension instructions
  267.  
  268. (define_insn "extendqihi2"
  269.   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
  270.         (sign_extend:HI (match_operand:QI 1 "general_operand" "r,m,i")) )]
  271.   ""
  272.   "@
  273.     lr  r%0,r%1 ;extendqihi2\;dsra r%0,16
  274.     l   r%0,%1  ;extendqihi2\;dsra r%0,16
  275.     lim r%0,%1  ;extendqihi2\;dsra r%0,16 ")
  276.  
  277.  
  278. ;; Conversions between float and double.
  279.  
  280. ; 1750 HF-to-TQF extend: just append 16 bits (least signif.) with all bits zero
  281. (define_insn "extendhftqf2"
  282.   [(set (match_operand:TQF 0 "register_operand" "=r,r")
  283.         (float_extend:TQF
  284.          (match_operand:HF 1 "general_operand" "r,m")))]
  285.   ""
  286.   "*
  287.       {
  288.         REGNO(operands[0]) += 2;
  289.         output_asm_insn(\"xorr r%0,r%0   ;extendhftqf2\",operands);
  290.         REGNO(operands[0]) -= 2;
  291.         if (which_alternative == 0)
  292.           return \"dlr r%0,r%1\";
  293.         else
  294.           return \"dl  r%0,%1\";
  295.       } ")
  296.  
  297. ; 1750 TQF-to-HF truncate is a no-op: just leave away the least signif. 16 bits
  298. (define_insn "trunctqfhf2"
  299.   [(set (match_operand:HF 0 "register_operand" "=r,r")
  300.         (float_truncate:HF
  301.           (match_operand:TQF 1 "general_operand" "r,m")))]
  302.   ""
  303.   "@
  304.      dlr r%0,r%1  ;trunctqfhf2
  305.      dl  r%0,%1   ;trunctqfhf2 ")
  306.  
  307.  
  308. ;; Conversion between fixed point and floating point.
  309.  
  310. (define_insn "floatqihf2"
  311.   [(set           (match_operand:HF 0 "register_operand" "=r")
  312.         (float:HF (match_operand:QI 1 "register_operand" "r")))]
  313.   ""
  314.   "flt r%0,r%1")
  315.  
  316. (define_insn "floathitqf2"
  317.   [(set           (match_operand:TQF 0 "register_operand" "=r")
  318.         (float:TQF (match_operand:HI 1 "register_operand" "r")))]
  319.   ""
  320.   "eflt r%0,r%1")
  321.  
  322.  
  323. ;; Convert floats to ints
  324.  
  325. (define_insn "fix_trunchfqi2"
  326.   [(set                 (match_operand:QI 0 "register_operand" "=r")
  327.         (fix:QI (fix:HF (match_operand:HF 1 "register_operand" "r"))))]
  328.   ""
  329.   "fix r%0,r%1")
  330.  
  331. (define_insn "fix_trunctqfhi2"
  332.   [(set                 (match_operand:HI 0 "register_operand" "=r")
  333.         (fix:HI (fix:TQF (match_operand:TQF 1 "register_operand" "r"))))]
  334.   ""
  335.   "efix r%0,r%1")
  336.  
  337.  
  338. ;; Move instructions
  339.  
  340. ;; We can't deal with normal byte-size characters, only with WIDE characters!
  341. ;; This may appear as a serious restriction, but it also opens the doors
  342. ;; for ISO 10646  :-)
  343.  
  344. ;; 16-bit moves
  345.  
  346. (define_insn "movqi"
  347.   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,r,r,r,m,m")
  348.         (match_operand:QI 1 "general_operand"  "O,I,J,M,i,r,m,r,K"))]
  349.   ""
  350.   "@
  351.      xorr r%0,r%0
  352.      lisp r%0,%1
  353.      lisn r%0,%J1
  354.      lim  r%0,%1  ; 'M' constraint
  355.      lim  r%0,%1  ; 'i' constraint
  356.      lr   r%0,r%1
  357.      l    r%0,%1
  358.      st   r%1,%0
  359.      stc  %1,%0   ")
  360.  
  361. ;; 32-bit moves
  362.  
  363. ;; Set HIreg to constant
  364. (define_insn ""
  365.   [(set (match_operand:HI 0 "register_operand" "=r")
  366.         (match_operand    1 "immediate_operand" "i"))]
  367.   ""
  368.   "*
  369.     if (GET_CODE(operands[1]) == CONST_INT)
  370.       {
  371.         int val = INTVAL(operands[1]);
  372.         if (val >= 0)
  373.           {
  374.             if (val <= 65535)
  375.               {
  376.                 output_asm_insn(\"xorr   r%0,r%0 ;movhi cst->reg\",operands);
  377.                 operands[0] = gen_rtx(REG,QImode,REGNO(operands[0]) + 1);
  378.                 if (val == 0)
  379.                   return \"xorr r%0,r%0\";
  380.                 else if (val <= 16)
  381.                   return \"lisp r%0,%1\";
  382.                 else
  383.                   return \"lim  r%0,%1\";
  384.               }
  385.           }
  386.         else if (val >= -16)
  387.           return \"lisn r%0,%J1\;dsra r%0,16 ;movhi cst\";
  388.         INTVAL(operands[1]) >>= 16;
  389.         output_asm_insn(\"lim r%0,%1 ;movhi cst->reg\",operands);
  390.         REGNO(operands[0]) += 1;
  391.         INTVAL(operands[1]) = val & 0xFFFF;
  392.         return \"lim r%0,%1\";
  393.       }
  394.     return \"lim r%0,%1\;dsra r%0,16 ;movhi cst\";
  395.   ")
  396.  
  397. (define_insn "movhi"
  398.   [(set (match_operand:HI 0 "general_operand" "=r,r,m")
  399.         (match_operand:HI 1 "general_operand"  "r,m,r"))]
  400.   ""
  401.   "@
  402.     dlr r%0,r%1
  403.     dl  r%0,%1
  404.     dst r%1,%0 ")
  405.  
  406.  
  407. ;; Single-Float moves are *same* as HImode moves:
  408.  
  409. ;(define_insn "movhf"
  410. ;  [(set (match_operand:HF 0 "general_operand" "=r,r,r,m")
  411. ;        (match_operand:HF 1 "general_operand"  "F,r,m,r"))]
  412. ;  ""
  413. ;  "@
  414. ;    %D1\;dl r%0,%F1
  415. ;    dlr r%0,r%1
  416. ;    dl  r%0,%1
  417. ;    dst r%1,%0 ")
  418.  
  419. (define_insn "movhf"
  420.   [(set (match_operand:HF 0 "general_operand" "=r,r,m")
  421.         (match_operand:HF 1 "general_operand"  "r,m,r"))]
  422.   ""
  423.   "@
  424.     dlr r%0,r%1
  425.     dl  r%0,%1
  426.     dst r%1,%0 ")
  427.  
  428.  
  429. ;; Longfloat moves
  430.  
  431. ;(define_insn "movtqf"
  432. ;  [(set (match_operand:TQF 0 "general_operand" "=r,r,r,m")
  433. ;        (match_operand:TQF 1 "general_operand"  "F,r,m,r"))]
  434. ;  ""
  435. ;  "@
  436. ;    %E1\;efl r%0,%G1
  437. ;    eflr.m %0,%1
  438. ;    efl  r%0,%1
  439. ;    efst r%1,%0 ")
  440.  
  441. (define_insn "movtqf"
  442.   [(set (match_operand:TQF 0 "general_operand" "=r,r,m")
  443.         (match_operand:TQF 1 "general_operand"  "r,m,r"))]
  444.   ""
  445.   "@
  446.     eflr.m %0,%1
  447.     efl  r%0,%1
  448.     efst r%1,%0 ")
  449.  
  450.  
  451. ;; add instructions 
  452.  
  453. ;; single integer
  454.  
  455. ;; Use "LIM Ra,sym,Rb" for adding a symbol value to a register and
  456. ;; transferring the result to a different register.
  457. ;(define_insn ""
  458. ;  [(set (match_operand:QI 0 "register_operand" "=r")
  459. ;        (plus:QI (match_operand:QI 1 "register_operand" "b")
  460. ;                 (match_operand:QI 2 "immediate_operand"  "i")))]
  461. ;   "REGNO(operands[0]) != REGNO(operands[1])"
  462. ;   "lim r%0,%2,r%1 ;md special addqi")
  463.  
  464. (define_insn "addqi3"
  465.   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,r,m,m")
  466.         (plus:QI (match_operand:QI 1 "general_operand" "%0,0,0,0,0,0,0")
  467.                  (match_operand:QI 2 "general_operand"  "I,J,i,r,m,I,J")))]
  468.   ""
  469.   "*
  470.     switch (which_alternative)
  471.       {
  472.         case 0:
  473.           return \"aisp r%0,%2\";
  474.         case 1:
  475.           return \"sisp r%0,%J2\";
  476.         case 2:
  477.           if (INTVAL(operands[2]) < 0)
  478.             return \"sim r%0,%J2\";
  479.           else
  480.             return \"aim r%0,%2\";
  481.         case 3:
  482.           return \"ar r%0,r%2\";
  483.         case 4:
  484.           return \"a r%0,%2\";
  485.         case 5:
  486.           return \"incm %2,%0\";
  487.         case 6:
  488.           return \"decm %J2,%0\";
  489.       } ")
  490.  
  491. ;; double integer
  492. (define_insn "addhi3"
  493.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  494.         (plus:HI (match_operand:HI 1 "register_operand" "%0,0")
  495.                  (match_operand:HI 2 "general_operand" "r,m")))]
  496.   ""
  497.   "@
  498.     dar r%0,r%2
  499.     da  r%0,%2 ")
  500.  
  501. (define_insn "addhf3"
  502.   [(set (match_operand:HF 0 "register_operand" "=r,r")
  503.         (plus:HF (match_operand:HF 1 "register_operand" "%0,0")
  504.                  (match_operand:HF 2 "general_operand" "m,r")))]
  505.   ""
  506.   "@
  507.     fa  r%0,%2
  508.     far r%0,r%2 ")
  509.  
  510. (define_insn "addtqf3"
  511.   [(set (match_operand:TQF 0 "register_operand" "=r,r")
  512.         (plus:TQF (match_operand:TQF 1 "register_operand" "%0,0")
  513.                  (match_operand:TQF 2 "general_operand" "m,r")))]
  514.   ""
  515.   "@
  516.     efa  r%0,%2
  517.     efar r%0,r%2 ")
  518.  
  519.  
  520. ;; subtract instructions
  521.  
  522. ;; single integer
  523. (define_insn "subqi3"
  524.   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,m")
  525.         (minus:QI (match_operand:QI 1 "general_operand" "0,0,0,0,0")
  526.                   (match_operand:QI 2 "general_operand"  "I,i,r,m,I")))]
  527.   ""
  528.   "@
  529.     sisp r%0,%2
  530.     sim  r%0,%2
  531.     sr   r%0,r%2
  532.     s    r%0,%2
  533.     decm %2,%0 ")
  534.  
  535. ;; double integer
  536. (define_insn "subhi3"
  537.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  538.         (minus:HI (match_operand:HI 1 "register_operand" "0,0")
  539.                   (match_operand:HI 2 "general_operand" "r,m")))]
  540.   ""
  541.   "@
  542.     dsr r%0,r%2
  543.     ds  r%0,%2 ")
  544.  
  545. (define_insn "subhf3"
  546.   [(set (match_operand:HF 0 "register_operand" "=r,r")
  547.         (minus:HF (match_operand:HF 1 "register_operand" "0,0")
  548.                   (match_operand:HF 2 "general_operand" "r,m")))]
  549.   ""
  550.   "@
  551.     fsr r%0,r%2
  552.     fs  r%0,%2 ")
  553.  
  554. (define_insn "subtqf3"
  555.   [(set (match_operand:TQF 0 "register_operand" "=r,r")
  556.         (minus:TQF (match_operand:TQF 1 "register_operand" "0,0")
  557.                   (match_operand:TQF 2 "general_operand" "r,m")))]
  558.   ""
  559.   "@
  560.     efsr r%0,r%2
  561.     efs  r%0,%2 ")
  562.  
  563.  
  564. ;; multiply instructions
  565.  
  566. (define_insn "mulqi3"
  567.   [(set (match_operand:QI 0 "register_operand" "=r,r,r,r,r")
  568.         (mult:QI (match_operand:QI 1 "register_operand" "%0,0,0,0,0")
  569.                  (match_operand:QI 2 "general_operand"  "I,J,M,r,m")))]
  570.   ""
  571.   "@
  572.      misp r%0,%2
  573.      misn r%0,%J2
  574.      msim r%0,%2
  575.      msr  r%0,r%2
  576.      ms   r%0,%2  ")
  577.  
  578.  
  579. ; 32-bit product
  580. (define_insn "mulqihi3"
  581.   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
  582.         (mult:HI (match_operand:QI 1 "register_operand" "%0,0,0")
  583.                  (match_operand:QI 2 "general_operand" "M,r,m")))]
  584.   ""
  585.   "@
  586.     mim r%0,%1
  587.     mr  r%0,r%2
  588.     m   r%0,%2 ")
  589.  
  590. (define_insn "mulhi3"
  591.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  592.         (mult:HI (match_operand:HI 1 "register_operand" "%0,0")
  593.                  (match_operand:HI 2 "general_operand" "r,m")))]
  594.   ""
  595.   "@
  596.     dmr r%0,r%2
  597.     dm  r%0,%2 ")
  598.  
  599. ; not available on 1750: "umulhi3","umulhisi3","umulsi3" (unsigned multiply's)
  600.  
  601. (define_insn "mulhf3"
  602.   [(set (match_operand:HF 0 "register_operand" "=r,r")
  603.         (mult:HF (match_operand:HF 1 "register_operand" "%0,0")
  604.                  (match_operand:HF 2 "general_operand" "r,m")))]
  605.   ""
  606.   "@
  607.     fmr r%0,r%2
  608.     fm  r%0,%2 ")
  609.  
  610. (define_insn "multqf3"
  611.   [(set (match_operand:TQF 0 "register_operand" "=r,r")
  612.         (mult:TQF (match_operand:TQF 1 "register_operand" "%0,0")
  613.                  (match_operand:TQF 2 "general_operand" "r,m")))]
  614.   ""
  615.   "@
  616.     efmr r%0,r%2
  617.     efm  r%0,%2 ")
  618.  
  619.  
  620. ;; divide instructions
  621. ;; The 1750 16bit integer division instructions deliver a 16-bit
  622. ;; quotient and a 16-bit remainder, where the remainder is in the next higher
  623. ;; register number above the quotient. For now, we haven't found a way
  624. ;; to give the reload pass knowledge of this property. So we make do with
  625. ;; whatever registers the allocator wants, and willy-nilly output a pair of
  626. ;; register-copy ops when needed. (See mod_regno_adjust() in file aux-output.c)
  627. ;; A comment in the description of `divmodM4' suggests that one leave the divM3
  628. ;; undefined when there is a divmodM4 available.
  629.  
  630. (define_insn "divmodqi4"
  631.   [(set (match_operand:QI 0 "register_operand" "=r,r,r,r,r")
  632.         (div:QI (match_operand:QI 1 "register_operand" "0,0,0,0,0")
  633.                 (match_operand:QI 2 "general_operand"  "I,J,M,r,m")))
  634.    (set (match_operand:QI 3 "register_operand" "=r,r,r,r,r")
  635.         (mod:QI (match_dup 1) (match_dup 2)))]
  636.   ""
  637.   "*
  638.    {
  639.      char *istr;
  640.      switch(which_alternative)
  641.        {
  642.        case 0:
  643.          istr = \"disp\";
  644.          break;
  645.        case 1:
  646.          INTVAL(operands[2]) = - INTVAL(operands[2]); /* to be corrected */
  647.          istr = \"disn\";
  648.          break;
  649.        case 2:
  650.          istr = \"dvim\";
  651.          break;
  652.        case 3:
  653.          istr = \"dvr \";
  654.          break;
  655.        case 4:
  656.          istr = \"dv  \";
  657.          break;
  658.       }
  659.       return (char *)mod_regno_adjust(istr,operands);
  660.      }")
  661.  
  662. ;; Division for other types is straightforward.
  663.  
  664. (define_insn "divhi3"
  665.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  666.         (div:HI (match_operand:HI 1 "register_operand" "0,0")
  667.                 (match_operand:HI 2 "general_operand" "r,m")))]
  668.   ""
  669.   "@
  670.     ddr r%0,r%2
  671.     dd  r%0,%2 ")
  672.  
  673. (define_insn "divhf3"
  674.   [(set (match_operand:HF 0 "register_operand" "=r,r")
  675.         (div:HF (match_operand:HF 1 "register_operand" "0,0")
  676.                 (match_operand:HF 2 "general_operand" "r,m")))]
  677.   ""
  678.   "@
  679.     fdr r%0,r%2
  680.     fd  r%0,%2 ")
  681.  
  682. (define_insn "divtqf3"
  683.   [(set (match_operand:TQF 0 "register_operand" "=r,r")
  684.         (div:TQF (match_operand:TQF 1 "register_operand" "0,0")
  685.                 (match_operand:TQF 2 "general_operand" "r,m")))]
  686.   ""
  687.   "@
  688.     efdr r%0,r%2
  689.     efd  r%0,%2 ")
  690.  
  691.  
  692. ;; Other arithmetic instructions:
  693.  
  694. ;; Absolute value
  695.  
  696. (define_insn "absqi2"
  697.   [(set (match_operand:QI 0 "register_operand" "=r")
  698.         (abs:QI (match_operand:QI 1 "register_operand" "r")))]
  699.   ""
  700.   "abs r%0,r%1")
  701.  
  702. (define_insn "abshi2"
  703.   [(set (match_operand:HI 0 "register_operand" "=r")
  704.         (abs:HI (match_operand:HI 1 "register_operand" "r")))]
  705.   ""
  706.   "dabs r%0,r%1")
  707.  
  708. (define_insn "abshf2"
  709.   [(set (match_operand:HF 0 "register_operand" "=r")
  710.         (abs:HF (match_operand:HF 1 "register_operand" "r")))]
  711.   ""
  712.   "fabs r%0,r%1")
  713.  
  714.  
  715. ;; Negation
  716.  
  717. (define_insn "negqi2"
  718.   [(set (match_operand:QI 0 "register_operand" "=r")
  719.         (neg:QI (match_operand:QI 1 "register_operand" "r")))]
  720.   ""
  721.   "neg r%0,r%1")
  722.  
  723. (define_insn "neghi2"
  724.   [(set (match_operand:HI 0 "register_operand" "=r")
  725.         (neg:HI (match_operand:HI 1 "register_operand" "r")))]
  726.   ""
  727.   "dneg r%0,r%1")
  728.  
  729. (define_insn "neghf2"
  730.   [(set (match_operand:HF 0 "register_operand" "=r")
  731.         (neg:HF (match_operand:HF 1 "register_operand" "r")))]
  732.   ""
  733.   "fneg r%0,r%1")
  734.  
  735. ; The 1750A does not have an extended float negate instruction, so simulate.
  736. (define_expand "negtqf2"
  737.   [(set (match_operand:TQF 0 "register_operand" "=&r")
  738.         (neg:TQF (match_operand:TQF 1 "register_operand" "r")))]
  739.   ""
  740.   "
  741.    emit_insn(gen_rtx(SET,VOIDmode,operands[0],CONST0_RTX(TQFmode)));
  742.    emit_insn(gen_rtx(SET,VOIDmode,operands[0],
  743.              gen_rtx(MINUS,TQFmode,operands[0],operands[1])));
  744.    DONE;
  745.   ")
  746.  
  747.  
  748. ;; bit-logical instructions
  749.  
  750. ;; AND
  751.  
  752. (define_insn "andqi3"
  753.   [(set (match_operand:QI 0 "general_operand" "=r,r,r")
  754.         (and:QI (match_operand:QI 1 "general_operand" "%0,0,0")
  755.                 (match_operand:QI 2 "general_operand" "M,r,m")))]
  756.   ""
  757.   "@
  758.     andm r%0,%2
  759.     andr r%0,r%2
  760.     and  r%0,%2 ")
  761.  
  762. ; This sets incorrect condition codes. See notice_update_cc()
  763. (define_insn "andhi3"
  764.   [(set (match_operand:HI 0 "register_operand" "=r")
  765.         (and:HI (match_operand:HI 1 "register_operand" "%0")
  766.                 (match_operand:HI 2 "register_operand" "r")))]
  767.   ""
  768.   "danr.m %0,%2")
  769.  
  770. ;; OR
  771.  
  772. (define_insn "iorqi3"
  773.   [(set (match_operand:QI 0 "general_operand" "=r,r,r")
  774.         (ior:QI  (match_operand:QI 1 "general_operand" "%0,0,0")
  775.                 (match_operand:QI 2 "general_operand" "M,r,m")))]
  776.   ""
  777.   "@
  778.     orim r%0,%2
  779.     orr  r%0,r%2
  780.     or   r%0,%2 ")
  781.  
  782. ; This sets incorrect condition codes. See notice_update_cc()
  783. (define_insn "iorhi3"
  784.   [(set (match_operand:HI 0 "register_operand" "=r")
  785.         (ior:HI (match_operand:HI 1 "register_operand" "%0")
  786.                 (match_operand:HI 2 "register_operand" "r")))]
  787.   ""
  788.   "dorr.m %0,%2")
  789.  
  790. ;; XOR
  791.  
  792. (define_insn "xorqi3"
  793.   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
  794.         (xor:QI (match_operand:QI 1 "register_operand" "%0,0,0")
  795.                 (match_operand:QI 2 "general_operand"  "M,r,m")))]
  796.   ""
  797.   "@
  798.     xorm r%0,%2
  799.     xorr r%0,r%2
  800.     xor  r%0,%2 ")
  801.  
  802. ; This sets incorrect condition codes. See notice_update_cc()
  803. (define_insn "xorhi3"
  804.   [(set (match_operand:HI 0 "register_operand" "=r")
  805.         (xor:HI (match_operand:HI 1 "register_operand" "%0")
  806.                 (match_operand:HI 2 "register_operand" "r")))]
  807.   ""
  808.   "dxrr.m %0,%2")
  809.  
  810. ;; NAND
  811.  
  812. (define_insn ""
  813.   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
  814.     (ior:QI (not:QI (match_operand:QI 1 "register_operand" "%0,0,0"))
  815.         (not:QI (match_operand:QI 2 "general_operand" "M,r,m"))))]
  816.   ""
  817.   "@
  818.     nim r%0,%2
  819.     nr  r%0,r%2
  820.     n   r%0,%2 ")
  821.  
  822. ; This sets incorrect condition codes. See notice_update_cc()
  823. (define_insn ""
  824.   [(set (match_operand:HI 0 "register_operand" "=r")
  825.     (ior:HI (not:HI (match_operand:HI 1 "register_operand" "%0"))
  826.         (not:HI (match_operand:HI 2 "register_operand" "r"))))]
  827.   ""
  828.   "dnr.m %0,%2")
  829.  
  830. ;; NOT
  831.  
  832. (define_insn "one_cmplqi2"
  833.   [(set (match_operand:QI 0 "register_operand" "=r")
  834.         (not:QI (match_operand:QI 1 "register_operand" "0")))]
  835.   ""
  836.   "nr r%0,r%0")
  837.  
  838. ; This sets incorrect condition codes. See notice_update_cc()
  839. (define_insn "one_cmplhi2"
  840.   [(set (match_operand:HI 0 "register_operand" "=r")
  841.         (not:HI (match_operand:HI 1 "register_operand" "0")))]
  842.   ""
  843.   "dnr.m %0,%0")
  844.  
  845.  
  846. ;; Shift instructions
  847.  
  848. ; (What to the 1750 is logical-shift-left, GCC likes to call "arithmetic")
  849. (define_insn "ashlqi3"
  850.   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
  851.         (ashift:QI (match_operand:QI 1 "register_operand" "0,0,0")
  852.                    (match_operand:QI 2 "general_operand" "O,I,r")))]
  853.   ""
  854.   "@
  855.     ; optimized away an SLL r%0,0
  856.     sll r%0,%2
  857.     slr r%0,r%2 ")
  858.  
  859. (define_insn "ashlhi3"
  860.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  861.         (ashift:HI (match_operand:HI 1 "register_operand" "0,0")
  862.                    (match_operand:QI 2 "general_operand" "L,r")))]
  863.   ""                        ; the 'L' constraint is a slight imprecise...
  864.   "@
  865.      dsll r%0,%2
  866.      dslr r%0,r%2 ")
  867.  
  868. (define_insn "lshrqi3"
  869.   [(set (match_operand:QI 0 "register_operand" "=r,r")
  870.         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0,0")
  871.                      (match_operand:QI 2 "general_operand" "I,r")))]
  872.   ""
  873.   "@
  874.     srl r%0,%2
  875.     neg r%2,r%2\;slr    r%0,r%2 ")
  876.  
  877. (define_insn "lshrhi3"
  878.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  879.         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0,0")
  880.                      (match_operand:QI 2 "general_operand" "L,r")))]
  881.   ""                        ; the 'L' constraint is a slight imprecise...
  882.   "@
  883.     dsrl r%0,%2
  884.     neg  r%2,r%2\;dslr   r%0,r%2 ")
  885.  
  886. (define_insn "ashrqi3"
  887.   [(set (match_operand:QI 0 "register_operand" "=r,r")
  888.         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0,0")
  889.                      (match_operand:QI 2 "general_operand" "I,r")))]
  890.   ""
  891.   "@
  892.      sra r%0,%2
  893.      neg r%2,r%2\;sar    r%0,r%2 ")
  894.  
  895. (define_insn "ashrhi3"
  896.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  897.         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0,0")
  898.                      (match_operand:QI 2 "general_operand" "I,r")))]
  899.   ""
  900.   "@
  901.      dsra r%0,%2
  902.      neg  r%2,r%2\;dsar   r%0,r%2 ")
  903.  
  904.  
  905. ;; rotate instructions
  906.  
  907. (define_insn "rotlqi3"
  908.   [(set (match_operand:QI 0 "register_operand" "=r,r")
  909.         (rotate:QI (match_operand:QI 1 "register_operand" "0,0")
  910.                    (match_operand:QI 2 "general_operand" "I,r")))]
  911.   ""
  912.   "@
  913.     slc r%0,%2
  914.     scr r%0,r%2 ")
  915.  
  916. (define_insn "rotlhi3"
  917.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  918.         (rotate:HI (match_operand:HI 1 "register_operand" "0,0")
  919.                    (match_operand:QI 2 "general_operand" "I,r")))]
  920.   ""
  921.   "@
  922.     dslc r%0,%2
  923.     dscr r%0,r%2 ")
  924.  
  925. (define_insn "rotrqi3"
  926.   [(set (match_operand:QI 0 "register_operand" "=r,r")
  927.         (rotatert:QI (match_operand:QI 1 "register_operand" "0,0")
  928.                      (match_operand:QI 2 "general_operand" "I,r")))]
  929.   ""
  930.   "@
  931.     slc r%0,%2
  932.     neg r%2,r%2\;scr    r%0,r%2 ")
  933.  
  934. (define_insn "rotrhi3"
  935.   [(set (match_operand:HI 0 "register_operand" "=r,r")
  936.         (rotatert:HI (match_operand:HI 1 "register_operand" "0,0")
  937.                      (match_operand:QI 2 "general_operand" "I,r")))]
  938.   ""
  939.   "@
  940.     dslc r%0,%2
  941.     neg  r%2,r%2\;dscr   r%0,r%2 ")
  942.  
  943.  
  944.  
  945. ;; Special cases of bit-field insns which we should
  946. ;; recognize in preference to the general case.
  947. ;; These handle aligned 8-bit and 16-bit fields,
  948. ;; which can usually be done with move instructions.
  949. ;    1750: t.b.d.
  950. ;********************
  951.  
  952. ;; Bit field instructions, general cases.
  953. ;; "o,d" constraint causes a nonoffsettable memref to match the "o"
  954. ;; so that its address is reloaded.
  955.  
  956. ;; (define_insn "extv" ...
  957.  
  958. ;; (define_insn "extzv" ...
  959.  
  960. ;; (define_insn "insv" ...
  961.  
  962. ;; Now recognize bit field insns that operate on registers
  963. ;; (or at least were intended to do so).
  964. ;[unnamed only]
  965.  
  966. ;; Special patterns for optimizing bit-field instructions.
  967. ;**************************************
  968.  
  969. ; cc status test ops n.a. on 1750 ......... e.g. "sleu" on 68k:
  970. ;  [(set (match_operand:QI 0 "general_operand" "=d")
  971. ;        (leu (cc0) (const_int 0)))]
  972. ;  ""
  973. ;  "* cc_status = cc_prev_status;
  974. ;     return \"sls %0\"; ")
  975.  
  976.  
  977. ;; Basic conditional jump instructions.
  978.  
  979. (define_insn "beq"
  980.   [(set (pc)
  981.         (if_then_else (eq (cc0)
  982.                           (const_int 0))
  983.                       (label_ref (match_operand 0 "" ""))
  984.                       (pc)))]
  985.   ""
  986.   "* return (char *)branch_or_jump(\"ez\",CODE_LABEL_NUMBER(operands[0]));
  987.   ")
  988.  
  989. (define_insn "bne"
  990.   [(set (pc)
  991.         (if_then_else (ne (cc0)
  992.                           (const_int 0))
  993.                       (label_ref (match_operand 0 "" ""))
  994.                       (pc)))]
  995.   ""
  996.   "* return (char *)branch_or_jump(\"nz\",CODE_LABEL_NUMBER(operands[0]));
  997.   ")
  998.  
  999. (define_insn "bgt"
  1000.   [(set (pc)
  1001.         (if_then_else (gt (cc0)
  1002.                           (const_int 0))
  1003.                       (label_ref (match_operand 0 "" ""))
  1004.                       (pc)))]
  1005.   ""
  1006.   "* return (char *)branch_or_jump(\"gt\",CODE_LABEL_NUMBER(operands[0]));
  1007.   ")
  1008.  
  1009. (define_insn "blt"
  1010.   [(set (pc)
  1011.         (if_then_else (lt (cc0)
  1012.                           (const_int 0))
  1013.                       (label_ref (match_operand 0 "" ""))
  1014.                       (pc)))]
  1015.   ""
  1016.   "* return (char *)branch_or_jump(\"lt\",CODE_LABEL_NUMBER(operands[0]));
  1017.   ")
  1018.  
  1019. (define_insn "bge"
  1020.   [(set (pc)
  1021.         (if_then_else (ge (cc0)
  1022.                           (const_int 0))
  1023.                       (label_ref (match_operand 0 "" ""))
  1024.                       (pc)))]
  1025.   ""
  1026.   "* return (char *)branch_or_jump(\"ge\",CODE_LABEL_NUMBER(operands[0]));
  1027.   ")
  1028.  
  1029. (define_insn "ble"
  1030.   [(set (pc)
  1031.         (if_then_else (le (cc0)
  1032.                           (const_int 0))
  1033.                       (label_ref (match_operand 0 "" ""))
  1034.                       (pc)))]
  1035.   ""
  1036.   "* return (char *)branch_or_jump(\"le\",CODE_LABEL_NUMBER(operands[0]));
  1037.   ")
  1038.  
  1039.  
  1040. ; no unsigned branches available on 1750. But GCC still needs them, so faking:
  1041.  
  1042. (define_insn "bgtu"
  1043.   [(set (pc)
  1044.         (if_then_else (gtu (cc0)
  1045.                           (const_int 0))
  1046.                       (label_ref (match_operand 0 "" ""))
  1047.                       (pc)))]
  1048.   ""
  1049.   "jc gt,%l0 ; Warning: this should be an *unsigned* test!")
  1050.  
  1051. (define_insn "bltu"
  1052.   [(set (pc)
  1053.         (if_then_else (ltu (cc0)
  1054.                           (const_int 0))
  1055.                       (label_ref (match_operand 0 "" ""))
  1056.                       (pc)))]
  1057.   ""
  1058.   "jc lt,%l0 ; Warning: this should be an *unsigned* test!")
  1059.  
  1060. (define_insn "bgeu"
  1061.   [(set (pc)
  1062.         (if_then_else (geu (cc0)
  1063.                           (const_int 0))
  1064.                       (label_ref (match_operand 0 "" ""))
  1065.                       (pc)))]
  1066.   ""
  1067.   "jc ge,%l0 ; Warning: this should be an *unsigned* test!")
  1068.  
  1069. (define_insn "bleu"
  1070.   [(set (pc)
  1071.         (if_then_else (leu (cc0)
  1072.                           (const_int 0))
  1073.                       (label_ref (match_operand 0 "" ""))
  1074.                       (pc)))]
  1075.   ""
  1076.   "jc le,%l0 ; Warning: this should be an *unsigned* test!")
  1077.  
  1078.  
  1079. ;; Negated conditional jump instructions.
  1080.  
  1081. (define_insn ""
  1082.   [(set (pc)
  1083.         (if_then_else (eq (cc0)
  1084.                           (const_int 0))
  1085.                       (pc)
  1086.                       (label_ref (match_operand 0 "" ""))))]
  1087.   ""
  1088.   "* return (char *)branch_or_jump(\"nz\",CODE_LABEL_NUMBER(operands[0]));
  1089.   ")
  1090.  
  1091. (define_insn ""
  1092.   [(set (pc)
  1093.         (if_then_else (ne (cc0)
  1094.                           (const_int 0))
  1095.                       (pc)
  1096.                       (label_ref (match_operand 0 "" ""))))]
  1097.   ""
  1098.   "* return (char *)branch_or_jump(\"ez\",CODE_LABEL_NUMBER(operands[0]));
  1099.   ")
  1100.  
  1101. (define_insn ""
  1102.   [(set (pc)
  1103.         (if_then_else (gt (cc0)
  1104.                           (const_int 0))
  1105.                       (pc)
  1106.                       (label_ref (match_operand 0 "" ""))))]
  1107.   ""
  1108.   "* return (char *)branch_or_jump(\"le\",CODE_LABEL_NUMBER(operands[0]));
  1109.   ")
  1110.  
  1111. (define_insn ""
  1112.   [(set (pc)
  1113.         (if_then_else (lt (cc0)
  1114.                           (const_int 0))
  1115.                       (pc)
  1116.                       (label_ref (match_operand 0 "" ""))))]
  1117.   ""
  1118.   "* return (char *)branch_or_jump(\"ge\",CODE_LABEL_NUMBER(operands[0]));
  1119.   ")
  1120.  
  1121. (define_insn ""
  1122.   [(set (pc)
  1123.         (if_then_else (ge (cc0)
  1124.                           (const_int 0))
  1125.                       (pc)
  1126.                       (label_ref (match_operand 0 "" ""))))]
  1127.   ""
  1128.   "* return (char *)branch_or_jump(\"lt\",CODE_LABEL_NUMBER(operands[0]));
  1129.   ")
  1130.  
  1131. (define_insn ""
  1132.   [(set (pc)
  1133.         (if_then_else (le (cc0)
  1134.                           (const_int 0))
  1135.                       (pc)
  1136.                       (label_ref (match_operand 0 "" ""))))]
  1137.   ""
  1138.   "* return (char *)branch_or_jump(\"gt\",CODE_LABEL_NUMBER(operands[0]));
  1139.   ")
  1140.  
  1141.  
  1142. ;; Negated unsigned conditional jump instructions (faked for 1750).
  1143.  
  1144. (define_insn ""
  1145.   [(set (pc)
  1146.         (if_then_else (gtu (cc0)
  1147.                           (const_int 0))
  1148.                       (pc)
  1149.                       (label_ref (match_operand 0 "" ""))))]
  1150.   ""
  1151.   "jc le,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
  1152.  
  1153. (define_insn ""
  1154.   [(set (pc)
  1155.         (if_then_else (ltu (cc0)
  1156.                           (const_int 0))
  1157.                       (pc)
  1158.                       (label_ref (match_operand 0 "" ""))))]
  1159.   ""
  1160.   "jc ge,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
  1161.  
  1162. (define_insn ""
  1163.   [(set (pc)
  1164.         (if_then_else (geu (cc0)
  1165.                           (const_int 0))
  1166.                       (pc)
  1167.                       (label_ref (match_operand 0 "" ""))))]
  1168.   ""
  1169.   "jc lt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
  1170.  
  1171. (define_insn ""
  1172.   [(set (pc)
  1173.         (if_then_else (leu (cc0)
  1174.                           (const_int 0))
  1175.                       (pc)
  1176.                       (label_ref (match_operand 0 "" ""))))]
  1177.   ""
  1178.   "jc gt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
  1179.  
  1180. ;; Tablejump 
  1181. ;; 1750 note: CASE_VECTOR_PC_RELATIVE is not defined
  1182. (define_insn "tablejump"
  1183.   [(set (pc)
  1184.         (match_operand:QI 0 "register_operand" "b"))
  1185.    (use (label_ref (match_operand 1 "" "")))]
  1186.   ""
  1187.   "jc 15,0,r%0   ; tablejump label_ref=%1")
  1188.  
  1189.  
  1190. ;; Unconditional jump
  1191. (define_insn "jump"
  1192.   [(set (pc)
  1193.         (label_ref (match_operand 0 "" "")))]
  1194.   ""
  1195.   "jc uc,%0")
  1196.  
  1197. ;; Call subroutine, returning value in operand 0
  1198. ;; (which must be a hard register).
  1199. (define_insn "call_value"
  1200.   [(set (match_operand 0 "register_operand" "r")
  1201.         (call (match_operand:QI 1 "memory_operand" "m")
  1202.               (match_operand:QI 2 "general_operand" "g")))]
  1203.   ;; Operand 2 not really used for 1750.
  1204.   ""
  1205.   "sjs r15,%1   ; return value in R0")
  1206.  
  1207. ;; Call subroutine with no return value.
  1208.  
  1209. ;;  Operand 1 not really used in MIL-STD-1750.
  1210. (define_insn ""
  1211.   [(call (match_operand:QI 0 "memory_operand" "mp")
  1212.          (match_operand:QI 1 "general_operand" ""))]
  1213.   ""
  1214.   "sjs r15,%0   ; no return value")
  1215.  
  1216. ;;;;;;;;;;;; 1750: NOT READY YET.
  1217. (define_insn "call"
  1218.   [(call (match_operand:QI 0 "" "")
  1219.          (match_operand:QI 1 "" ""))]
  1220.   ""
  1221.   "ANYCALL %0")
  1222.  
  1223.  
  1224. ; (define_insn "return"
  1225. ;   [(return)]
  1226. ;   ""
  1227. ;   "*
  1228. ;    { 
  1229. ;         rtx oprnd = gen_rtx(CONST_INT,VOIDmode,get_frame_size());
  1230. ;         output_asm_insn(\"ret.m  %0\",&oprnd);
  1231. ;         return \"\;\";
  1232. ;    } ")
  1233.  
  1234. (define_insn "indirect_jump"
  1235.   [(set (pc) (match_operand:QI 0 "address_operand" "p"))]
  1236.   ""
  1237.   "jci 15,%0")
  1238.  
  1239. (define_insn "nop"
  1240.   [(const_int 0)]
  1241.   ""
  1242.   "nop")
  1243.  
  1244.  
  1245. ;; Subtract One and Jump (if non-zero)
  1246. (define_peephole 
  1247.   [(set (match_operand:QI 0 "register_operand" "=r")
  1248.         (plus:QI (match_operand:QI 1 "register_operand" "%0")
  1249.                  (match_operand:QI 2 "immediate_operand" "J")))
  1250.    (set (cc0) (match_dup 0))
  1251.    (set (pc)
  1252.         (if_then_else (ne (cc0) (const_int 0))
  1253.          (label_ref (match_operand 3 "" ""))
  1254.          (pc)))
  1255.    ]
  1256.   "INTVAL(operands[2]) == -1"
  1257.   "soj r%0,%3")
  1258.  
  1259. ;;;End.
  1260.  
  1261.